Rage récolte du bois. Il en ramasse une grande quantité. Dans son inventaire, il ne peux faire des piles (stack en anglais)
uniquement de 500 morceaux de bois. On aimerait disposer d'une fonction qui renvoie le nombre de piles complètes et
le niveau de remplissage du dernier stack.
-
Écrire une fonction stacking(dropped) qui a une quantité d'objets ramassés dropped
renvoie le nombre de piles à 500 éléments et le nombre de morceaux de la dernière pile incomplète.
Par exemple stacking(1232) renvoie 2, 232 pour 2 stacks à 500 morceaux de bois et un stack de 232 morceaux de bois.
Il peut vous être utile d'utiliser les deux opérateurs // et % définis ainsi :
-
Appeler cette fonction afin de mettre en stack 15352 morceaux de bois.
Exercice de renforcement 
Voici un exercice à faire en autonomie pour tester votre maîtrise des bases sur les fonctions.
Cet exercice est issu du site d'un collègue de NSI Jean Diraison.
Une fois le code complété, cliquer sur les boutons Exécuter pour
exécuter votre script et Vérifier la réponse afin de tester votre script
sur des quelques cas.
À la dixième vérification, une proposition de correction est affichée afin de vous aider à progresser.
Cliquer sur ce lien pour accéder à l'exercice.
Voici un exercice à faire en autonomie pour tester votre maîtrise des bases sur les fonctions.
Cet exercice est issu du site collaboratif de la forge.
La dernière question de l'exercice est intéressante puisque vous aurez à utiliser les fonctions
construites dans les premières questions, mais faites attention à la conversion Wh / kWh !
Cliquer sur ce lien pour accéder à l'exercice.
Bonnes pratiques de programmation
Préciser le typage de chacun des paramètres
Le langage Python est plus aisé pour démarrer la programmation pour la concision des codes écrits et pour la gestion automatique du typage par l'interpréteur. Cependant, le but est que vous puissiez à terme être capable de faire basculer
vos compétences acquises en NSI sur Python vers d'autres langages de programmation.
Comme la plupart des langages de programmation nécessitent la spécification du typage des variables, à terme, on vous demandera d'écrire en Python, une fonction en précisant le type de chaque entrée et sortie en suivant le même formalisme
que ci-dessous :
def nom_fonction(liste des arguments: type) -> typeRetour:
blocs des instructions
return resultat
La convention PEP8 donne l'habitude de nommer les fonctions (comme les variables) avec des lettres minuscules des soulignés bas (touche du "8") _.
Pour clarifier la fonction, il est conseillé
d'utiliser un verbe dans son nom (obtenir, donner, get, set, ...).
def set_pv(pv_player: float, attaque: int) -> float:
pv_player = pv_player - attaque
return pv_player
Documenter ses fonctions
Il est important de documenter vos fonctions, c'est-à-dire de décrire en quelques phrases le rôle de la fonction, de donner des informations sur la fonction, le lien entre les entrées et la sortie.
Pour cela, juste en dessous de la première ligne définissant la fonction, il suffit de mettre ses informations entre """ et """ ; c'est ce que l'on appelle en franglais le docstring de la fonction). En reprenant l'exemple précédent (sans le typage), on peut écrire :
def set_pv(pv_player: float, attaque: int) -> float:
"""
Renvoie le nombre de point de vie du joueur auquel on retire la valeur contenu dans la variable attaque.
"""
pv_player = pv_player - attaque
return pv_player
L'intérêt de l'auto-documentation d'une fonction par un texte est double :
-
Pour vous : le faire vous oblige à réfléchir au contenu de votre fonction avant de la programmer ; c'est un gain
d'efficacité,
-
Pour les utilisateurs de votre code (ou pour vous longtemps après avoir programmé la fonction)
help
Quand on saisit dans la console, après l'exécution de la fonction, l'instruction help(nom de la fonction), Python affiche
le docstring de la fonction ce qui nous permet d'avoir des informations sur la fonction en cas d'oubli.
>>> help(set_pv)
Help on function set_pv in module __main__:
set_pv(pv_player: float, attaque: int) -> float
Renvoie le nombre de point de vie du joueur auquel on retire la valeur contenu dans la variable attaque.
>>>
Voici ci-dessous une fonction qui renvoie le niveau d'armure du joueur en disposant comme argument le niveau d'armure base_armor et le niveau d'usure de l'armure armor_damage exprimé en pourcentage.
def set_armor(base_armor, armor_damage):
armor = base_armor * (1 - armor_damage/100)
return armor
Améliorer le code précédent en préciser le typage de chaque paramètre et en documentant cette fonction.
Exercice de renforcement
Utilisation de modules
Nous avons déjà vues les fonctions print et input. Ce sont deux fonctions prédéfinies dans le langage Python, On appelle ce type de fonction des fonctions natives au langage Python
, elles sont directement utilisables.
D'autres fonctions ont été développées et testées par différents programmeurs mais ne sont pas directement utilisables. Ces fonctions sont regroupées dans des modules, appelés aussi bibliothèques.
En terminale, vous apprendrez même à en créer par vous même !
-
le module math contient de nombreuses fonctions mathématiques usuelles comme la racine carrée (sqrt), ...
-
le module random contient de nombreuses fonctions modélisant le hasard comme l'obtention d'un nombre entier aléatoire compris entre deux nombres entiers a et b (randint(a, b)), ...
-
le module matplotlib.pyplot permet de réaliser des graphiques, des tracés de courbes, ...
Pour pouvoir utiliser ces fonctions, il faut d'abord importer ces modules. Pour cela, il y a plusieurs méthodes :
Il existe plusieurs manières pour importer des fonctions d'un module :
-
Soit importer toutes les fonctions du module en ajoutant en début de programme :
from nom_module import *
On peut alors utiliser n'importe qu'elle fonction du module sans prendre en utilisant seulement son nom.
-
Il peut suffire d'importer seulement une fonction d'un module en
ajoutant en début de programme :
from nom_module import nom_fonction
-
Exemple de l'importation de tout le contenu du module math pour pouvoir
utiliser la fonction racine carrée nommée sqrt en Python :
from math import * # importation de toutes les fonctions du module math
a = (1 + sqrt(5))/2
print("valeur approchée du nombre d'or :", a)
-
Exemple de l'importation de la seule fonction
racine carrée nommée sqrt depuis le module math :
from math import sqrt # importation de toutes les fonctions du module math
a = (1 + sqrt(5))/2
print("valeur approchée du nombre d'or :", a)
L'importation avec from module import * est fortement déconseillée
par la PEP8 (conventions
d'écriture de codes en Python).
L'importation de tout ou partie d'un module peut poser problème : si une fonction
importée porte le même nom qu'une fonction déjà définie en finie, la fonction importée
écrase la fonction initiale.
Pour éviter ce problème, il est préférable d'importer le module puis d'utiliser
la fonction en précisant qu'elle est issue de ce module.
La manière conseillée pour importer des fonctions d'un module est :
-
d'importer d'abord tout le module avec
import nom_module
-
d'appeler la fonction en précisant devant le nom du module :
nom_module.fonction_utilisee()
Exemple de l'importation de tout le module math
puis utilisation de la seule fonction
racine carrée nommée sqrt :
import math # importation du module en premier
a = (1 + math.sqrt(5))/2 # Remarquez bien le "math.sqrt" au lieu de simplement "sqrt"
print("valeur approchée du nombre d'or :", a)
On peut fixer un nom d'utilisation à un module importé ayant un nom
initial long avec :
import nom_module_long_a_ecrire as nom_court
Le module matplotlib.pyplot servant à des représentations
graphique à un nom très long.
On peut lui donner un alias c'est-à-dire un nom
d'appel court comme par exemple plt comme ci-dessous :
import matplotlib.pyplot as plt # import de toutes les fonctions du module matplotlib.pyplot mentionné plt dans toute la suite du programme
plt.grid() # utilisation de la fonction grid (qui permet d'obtenir un quadrillage), fonction issue du module plt (=matplotlib.pyplot)
plt.show() # utilisation de la fonction show (qui permet de réaliser le tracé du code précédent), fonction issue du module plt (=matplotlib.pyplot)
Le module random contient de nombreuses fonctions modélisant
des nombres aléatoires.
La fonction randint est une de ces fonctions.
Sachant que randint(a, b) renvoie un
nombre aléatoire entier compris entre a inclus
et b lui aussi inclus, proposer un script
qui affiche le résultat du lancer d'un dé cubique équilibré (six résultats possibles : 1, 2, 3, 4, 5 ou 6)
La portée des variables
Il faut faire la différence entre les variables utilisées dans le programme (variables globales) et les variables utilisées dans une fonction (variables locales).
Vous allez comprendre cela à l'aide des exemples de l'exercice suivant :
Réaliser des appels des trois fonctions suivantes pour comprendre la différence entre leurs codes :
-
pv_player = 100
def set_pv_1(pv_player, attack):
pv_player = pv_player - attack
return pv_player
print(set_pv_1(50, 25))
-
pv_player = 100
def set_pv_2(attack):
pv_player = pv_player - attack
return pv_player
print(set_pv_2(25))
-
pv_player = 100
def set_pv_3(attack):
global pv_player
pv_player = pv_player - attack
return pv_player
print(set_pv_3(25))
Exercice de renforcement
Normalement vous avez dû détecter un problème : il y a une fonction qui ne peut pas être interprétée !
Il faut privilégier les variables locales. La première écriture, celle de set_pv_1 est la définition à privilégier.
Vous pouvez utiliser des variables globales, comme mais dans set_pv_3, des cas qu'il faudra bien définir en amont.
Le danger des variables globales est qu'elles peuvent être modifiées à différents endroits d'un programme ce qui rend plus difficile
la prévision du comportement du programme, dès que celui-ci devient assez conséquent.
Le seul moment où on pourra utiliser les variables globales , c'est à la construction de jeu ( ou autre appli ) en programmation itérative (celle de première).
-
Voici une fonction set_score qui prend comme paramètre d'entrée les points à rajouter et renvoie le nouveau score obtenu.
def set_score(points: int) -> int:
"""
fonction qui renvoie le score du nombre de points donnés comme entrée
paramètres :
points : nombre de points à rajouter à la variable globale score (nombre entier)
retour :
score : nombre de points du score (nombre entier)
"""
global score
score = score + points
return score
Combien de variables apparaissent dans la fonction set_score ? De quel type ?
-
Exécuter le script suivant :
score = 100
def set_score(points: int) -> int:
"""
fonction qui renvoie le score du nombre de points donnés comme entrée
paramètres :
points : nombre de points à rajouter à la variable globale score (nombre entier)
retour :
score : nombre de points du score (nombre entier)
"""
global score
score = score + points
return score
for parties in range(1, 4): # 3 répétitions de l'affichage suivant
print("J'ai gagné 10 points ! set_score(10) affiche :", set_score(10))
Est-ce que les appels set_score(10) renvoie toujours la même valeur ?
-
Comme il est préférable d'éviter les variables globales, proposer une modification de la fonction set_score afin de supprimer la ligne global score.
Rajouter un paramètre à la fonction peut-être très utile pour supprimer une variable globale.
-
Tester le script complet précédent avec la fonction set_score modifiée.
-
La structure générale d'une fonction :
def nom_fonction(liste des arguments: type) -> typeRetour:
blocs des instructions
return resultat
-
L'indentation permet de définir ce qui fait partie de la fonction de ce qui en est exclu.
-
Une fois une fonction définie, pensez à l'appeler pour l'utiliser.
-
Toujours terminer une fonction par un return qui doit être pour le mieux unique.
-
Essayer de préciser les types des paramètres et du retour dans l'en-tête d'une fonction.
-
Essayer de documenter ses fonctions : texte explicatif entre triples guillemets ou apostrophes.
-
Essayer d'éviter l'utilisation de variables globales.
-
On peut importer une fonction nom_fonction d'un module nom_module avec :
Précondition et postconditions en Python
Précondition
Voici le code en Python d'une fonction nommée get_unite qui prend comme paramètre un nombre entier et qui renvoie son chiffre des unités.
def get_unite(n: int) -> int:
"""
renvoie le chiffre des unités d'un entier n
"""
while n >= 10 : # répétition tant que n est supérieur ou égal à 10
n = n - 10
return n
Une documentation a été donnée afin d'expliciter le bon usage de la fonction. Mais on ne pas être certain qu'un utilisateur de la fonction respectera les contraintes implicites ou explicites de la documentation et du typage. Voici quelques exemples d'appel
de la fonction :
>>> get_unite(4567)
7
>>> get_unite(45.67)
5.670000000000002
>>> get_unite(-6)
-6
On voit que l'appel conduit à une réponse à chaque fois, mais que celle-ci ne correspond pas toujours à ce qui est attendu. Pour rendre "robuste" la fonction précédente, on doit vérifier au début de celle-ci certaines contraintes de bon usage que l'on
appelle
précondition.
Une précondition est une propriété (sur le type, sur les valeurs possibles, ...) vérifiée
au début de l'exécution d'une fonction.
Dans l'exemple précédent, ces préconditions sont :
-
"Précondition 1" : n est de type entier (par exemple, le programme buguera si une chaîne de caractères
est saisie come argument).
-
"Précondition 2" : n est positif (sinon le résultat renvoyé est la valeur négative saisie).
Pour cela, le langage Python possède le mot-clef assert qui permet un mécanisme d'assertion.
Les deux préconditions précédentes s'ajoutent à la fonction précédente ainsi :
def get_unite(n: int) -> int:
"""
renvoie le chiffre des unités d'un entier n
"""
assert type(n) == int, "vous devez entrer un nombre entier." # "Précondition 1"
assert n >= 0, "le nombre étudié doit être positif ou nul." # "Précondition 2"
while n >= 10 : # répétition tant que n est supérieur ou égal à 10
n = n - 10
return n
Quelques explications :
-
a == b renvoie True si l'égalité "a=b" est vraie (même type et même contenu) et
False sinon,
-
int est le type "entier". Il existe les types float pour les flottants,
str pour les chaînes de caractères, ...
-
Le mot-clé assert est suivi :
-
d'une condition (une expression booléenne qui vaut True ou False),
-
éventuellement suivie d'une virgule , et d'une phrase en langue naturelle, sous forme d'une
chaîne de caractères.
assert
Le mot-clé assert teste sa condition. Deux cas possibles :
-
si la condition est satisfaite, elle ne fait rien (l'interpréteur passe à la ligne suivante),
-
sinon elle arrête immédiatement l'exécution du programme en affichant la phrase qui lui est éventuellement associée. Ainsi, l'interpréteur arrête l'exécution de la fonction plutôt que de faire planter
le programme et affiche un message clair pour corriger l'erreur !
Vous pouvez retrouver ici une petite vidéo qui synthétise les appels de modules, les docstring et les assert
Voici un fonction nommée diviser réalisation la division du premier argument par le second.
def diviser(a: float, b: float) -> float:
"""
renvoie le résultat décimal de la division de a par b.
"""
return a/b
Quelle précondition, écrite en langage Python, doit-on rajouter afin d'assurer le bon fonctionnement de la fonction ?
Pour tester une différence, on utilise en langage Python l'opérateur !=.
Par exemples, l'expression 2*3 != 3 prend la valeur True car $2\times 3\neq 3$,
tandis que l'expression 2*3 != 6 prend la valeur False car $2\times 3 = 6$.
Exercice de renforcement
Postcondition
Souvent les fonctions sont appelées au cours de programme ; le type et la qualité du résultat renvoyé sont importants
pour ne pas conduire à un plantage. Des contraintes sur la variable renvoyée sont souvent nécessaires : on les appellent les
postconditions.
Une postcondition est une propriété (sur le type, sur les valeurs possibles, ...) vérifiée
à la fin de l'exécution d'une fonction.
Reprenons l'exemple précédent :
def get_unite(n: int) -> int:
"""
renvoie le chiffre des unités d'un entier n
"""
while n >= 10 : # répétition tant que n est supérieur ou égal à 10
n = n-10
return n
Voici le résultat de quelques appels effectués :
>>> get_unite(4567)
7
>>> get_unite(45.67)
5.670000000000002
>>> get_unite(-6)
-6
Comme le résultat renvoyé doit être un nombre entier compris entre 0 et 9, on va rajouter les postconditions suivantes :
-
"postcondition 1" : n est un entier naturel.
-
"postcondition 2" : n est positif.
-
"postcondition 3" : n est strictement inférieur à 10.
On utilise encore le mot-clé assert, juste avant le return pour écrire ces postconditions comme montré ci-dessous :
def get_unite(n: int) -> int:
"""
renvoie le chiffre des unités d'un entier n
"""
while n >= 10 : # répétition tant que n est supérieur ou égal à 10
n = n - 10
assert type(n) == int, "Le nombre renvoyé devrait être un entier." # "Postcondition 1"
assert n >= 0, "le nombre renvoyé doit être positif ou nul." # "Postcondition 2"
assert n < 10, "le nombre renvoyé doit être inférieur à 10." # "Postcondition 3"
return n
Exercice de renforcement
-
Ces mécanisme d'assertion est une aide au développeur qui permet de repérer des
erreurs dans le code.
-
En supprimant toutes les assertions, le programme doit à la fin toujours fonctionner.
-
Normalement, Lors de la finalisation du programme les différentes assertions doivent être ôtées.
-
Le mot-clé assert est utilisé pour créer un jeu de tests pour vérifier qu'une fonction
renvoie un résultat correct dans des cas prédéfinis.
Cette utilisation est par exemple vu dans l'autotest suivant.
-
Une précondition est une propriété vérifiée au début de l'exécution d'une fonction.
-
Une postcondition est une propriété vérifiée à la fin de l'exécution d'une fonction.
-
Dans le langage Python, une pré/postcondition commence par le mot-clé
assert.
-
Le mot-clef assert est suivi :
-
d'une condition, qui vaut True ou False,
-
éventuellement suivie d'une virgule , et d'une phrase en langue naturelle, sous forme
d'une chaîne de caractères.
-
Le mot-clé assert teste la condition. Deux cas possibles :
-
si la condition est satisfaite, l'interpréteur passe à la ligne suivante,
-
sinon elle arrête immédiatement l'exécution du programme en affichant la phrase qui lui
est éventuellement associée. Ainsi, l'interpréteur arrête l'exécution de la fonction plutôt que
de faire planter
le programme et affiche un message clair pour corriger l'erreur !
Suivre l'état des variables pas à pas : trace d'exécution et Python Tutor
Il existe différentes manières de réaliser une trace de programme et/ou d'algorithme. Une trace :
-
permet de suivre pas à pas l'algorithme ;
-
permet de détecter des erreurs ;
-
permet de contrôler que l'algorithme fait bien ce que l'on avant prévu ;
-
permet de comprendre ce que fait un algorithme.
Dans la mesure du possible, on peut organiser une trace d'exécution d'un algorithme en constituant un tableau avec toutes les variables de l'algorithme. Il faut numéroter toutes les lignes de votre algorithme. En colonne,
il faut indiquer le nom des variables et en ligne les numéros de ligne.
On considère l'algorithme suivant :
1 pv_player = 40
2 attack = 10
3 pv_player = pv_player - attack
4 attack = 2 * attack
5 pv_player = pv_player - attack
Regarder la vidéo, elle vous montre comment faire une trace d'exécution.
Une solution numérique (plus simple qu'une trace d'execution) est proposée sur le PythonTutor.
Tester cette procédure avec PythonTutor :
def letter_by_letter(ch):
for elt in ch :
print(elt)
letter_by_letter("Une société écologique, c'est une société qui trouve le point d'équilibre entre la société matérialiste absolue dans laquelle nous sommes et une société qui voudrait tomber dans une spiritualité béate qui ne serait pas plus intéressante.")
Des exercices
Fonction
L'Indice de Masse Corporelle (IMC)est un nombre réel utilisé en médecine. Sa formule est pour une $masse$ en kilos et une $taille$ en mètres : $IMC = \frac{masse}{taille^2}$.
-
Écrire une fonction IMC qui prend deux paramètres
masse et taille correspondant
respectivement à la masse en kg et la taille en mètre
et qui renvoie la valeur de l'IMC correspondant.
-
Tester la fonction en vérifiant que IMC(1.75, 98)
renvoie 32.0 et IMC(1.68, 64)
renvoie 22.67573696145125.
-
Pourquoi cette fonction s'appelle bien une fonction et non une procédure ?
-
Écrire en langage Python dans Jupyter un programme qui :
-
Demande la masse de l'utilisateur en kg (nombre réel),
-
Demande la taille de l'utilisateur en cm (nombre entier),
-
fait appel à la fonction IMC précédemment créée (en
prenant garde aux unités),
-
affiche finalement en console l'IMC de l'utilisateur.
-
Vérifier qu'une personne de 80 kg mesurant 1 mètre 80 a un IMC proche de 24.691358024691358.
Exercice de renforcement
Fonction
-
Écrire une fonction saisir_nom qui ne prend pas de paramètre mais renvoie le nom saisi par l'utilisateur comme chaîne de caractères.
-
Est-ce une fonction ou une procédure ? Pourquoi ?
-
Écrire une fonction nommée dire_bonjour ayant comme paramètre un mot qui affiche bonjour suivi du mot.
Exemple : dire_bonjour("Paul") affiche "Bonjour Paul !".
-
Est-ce une fonction ou une procédure ? Pourquoi ?
-
Proposer un programme qui :
-
intègre d'abord les deux fonctions précédentes,
-
qui utilise ces deux fonctions dans le corps principal du programme
Ce programme :
Exercice de renforcement
Précondition
-
Écrire une fonction nommée get_moyenne qui renvoie la moyenne de trois nombres quelconques passés en arguments.
-
Proposer une précondition portant sur chacun des paramètres d'entrée pour assurer que la possibilité de calculer la somme.
Exercice de renforcement
Fonction
Écrire une fonction appelée echanger qui échange les valeurs
de deux paramètres a et b.
Par exemple, echanger("mot", 12) renvoie (12, "mot").
La possibilité de stocker un entier dans une variable stockant initialement une chaîne de caractères est possible en Python car c'est un langage non typé : l'interpréteur gère automatiquement le
typage. Attention ! Dans beaucoup d'autres langages de programmation, cela n'est pas possible.
Précondition
-
Documenter la fonction suivante en ajoutant un docstring.
def examen(x, y, z, t):
m = (2*x + 2*y + z + t)/6
if m >= 10:
print("Le candidat est reçu")
else :
print("le candidat est refusé")
return None
-
Proposer des préconditions écrites sur les variables x, y,
z et t en utilisant le mot-clé assert qui assurent le bon usage de cette fonction
examen.
Exercice de renforcement
Fonction
Voici une fonction cherche_lettre qui affiche si le caractère lettre est présent ou non dans le nom saisi nom, tout deux entrés comme paramètre de la fonction :
def cherche_lettre(nom, lettre):
if lettre in nom:
print(lettre, " est dans le nom ", nom)
else:
print(lettre, "n' est pas dans le nom ", nom)
return None
-
Préciser le type de chacun des paramètres d'entrée.
-
Est-ce une fonction ou une procédure ?
-
Proposer des préconditions écrites sur les variables nom et lettre en utilisant le mot-clef assert qui assurent le bon usage de cette fonction cherche_lettre.
La longueur d'une chaîne de caractères (c'est-à-dire le nombre de caractères) nommée chaine en Python s'obtient avec la commande len(chaine).
Exercice de renforcement
Travail complémentaire
Les exercices qui suivent nécessitent d'utiliser les mot-clef if, for ou while ainsi que des listes.
-
Écrire une fonction div_euclidienne qui prend en paramètre deux nombres entiers a et b, qui effectue la division euclidienne de a par b et qui renvoie
le couple (q, r), respectivement le quotient et le reste de cette division euclidienne.
Un tel couple est appelé tuple.
-
Proposer des préconditions sur les paramètres a et b afin d'assurer le bon usage de la fonction
div_euclidienne.
-
Proposer des postconditions sur les deux valeurs renvoyées (q et r) afin d'assurer le bon usage de la fonction
div_euclidienne.
Voici un algorithme écrit en pseudo-code :
1 PG ← 0
2 IPG ← 0
3 n ← longueur de la liste
4 for i← 0 to n-1
5 if liste[i] > PG then
6 PG ← liste[i]
7 IPG ← i
On admet que la variable PG contient à la fin de l'algorithme la valeur maximale
de la liste liste et la variable IPG à la position de ce
maximum dans la liste.
-
Écrire une fonction get_max_position qui prend en paramètre une liste et qui renvoie le couple (le tuple) (PG, IG), respectivement la plus grande valeur de la liste et la position de cette valeur
maximale dans la liste.
Indications :
-
Une liste en python se note entre crochet [ ] chaque élément étant séparée d'une virgule.
-
la longueur d'une liste nommée liste en Python s'obtient avec la commande
len(liste)
-
Chaque élément d'une liste est positionné à l'aide d'un index compris entre 0 et
len(liste) - 1.
-
L'élément d'une liste nommée liste positionné à l'index i est obtenu avec :
liste[i].
-
Proposer des postconditions sur la valeur renvoyée IG afin d'assurer le bon usage de la fonction
get_max_position.
Écrire une fonction get_max qui prend en paramètre une liste et renvoie le max des éléments de celle-ci.
-
Une liste en python se note entre crochet [ ] chaque élément étant séparée d'une virgule ,
.
-
la longueur d'une liste nommée liste en Python s'obtient avec la commande len(liste).
Exercices de renforcement
L'ensemble des exercices de renforcement sont corrigés et expliqués dans le document Jupyter accessible avec ce
lien.
On veut pouvoir convertir une durée en heures en une spécifiant le nombre de jours et le nombre d'heures correspondant. Pour cela, il suffit de créer une fonction.
-
Définir une fonction convertir_jour qui prend comme paramètre un entier duree_heure en renvoie un tuple (=couple ici) formé des deux valeurs nb_jours et
nb_heures.
-
Appeler cette fonction afin de convertir en nombres de jours 260 heures.
Cliquer pour afficher la solution
-
def convertir_jour(duree_heure):
nb_jours = duree_heure // 24
nb_heures = duree_heure % 24
return nb_jours,nb_heures
-
convertir_jour(260)
L'appel renvoie (10, 20)
Voici ci-dessous une fonction qui donne le prix TTC connaissant le prix Hors Taxe pour une TVA à t% :
def TTC(HT, t):
TTC = HT * (1 + t/100)
return TTC
Améliorer le code précédent en préciser le typage de chaque paramètre et en documentant cette fonction.
Cliquer pour afficher la solution
def TTC(HT: float, t: int) -> float:
"""
fonction qui renvoie le prix TTC connaissant le prix Hors Taxe (HT) et la taux de TVA (t)
HT est un nombre réel
t est un entier compris entre 0 et 100
"""
TTC = HT * (1 + t/100)
return TTC
Parmi les scripts suivants, le(s)quel(s) peuvent correspondre à l'utilisation de la fonction inverse pour calculer l'image de 4 :
# script 1 :
x = 4
def fct1(x):
x = 1/x
return x
# script 2 :
x = 4
def fct2():
x = 1/x
return x
# script 3 :
def fct3(x):
return 1/x
# script 4 :
x = 4
def fct4():
global x
x = 1/x
return x
Cliquer pour afficher la solution
-
Le premier script est correct si l'on appelle bien ensuite fct1(4).
En fait la ligne `x = 4` est inutile.
C'est lors de l'appel que l'on affecte une valeur aux paramètres de la fonction, inutile d'affecter une valeur à une variable
en lien avec
un paramètre avant la fonction.
-
Le second script n'est pas correct : la variable x à l'intérieur de la fonction n'est pas définie en interne.
La ligne `x = 4` étant externe à la fonction, elle ne suffit pas.
Il est essentiel de même en paramètre les variables externes que l'on voudrait utiliser dans la fonction.
De plus, c'est lors de l'appel que l'on affecte une valeur à ces paramètres, inutile de le faire avant la fonction.
-
Le troisième script est correct si l'on appelle bien ensuite fct3(4).
On peut dans la ligne du return directement effectuer un calcul dont le résultat sera renvoyé.
Python évalue toujours l'expression avant de renvoyer la valeur (tout comme il évalue toujours avant d'affecter).
-
Le dernier script est correct si l'on appelle bien ensuite fct4().
Ici, une variable globale remplace l'utilisation d'un paramètre.
La valeur de cette variable est définie en-dehors de la fonction et la fonction modifie la valeur de cette variable.
Ceci est à éviter en programmation car cela rend le programme plus difficilement prévisible et contrôlable.
Un moyen d'estimer la profondeur d'un puits est de lâcher une pierre au dessus du puits et de compter le nombre
de secondes avant d'entendre le bruit du "plouf" de son entrée dans l'eau. On note $t$ la durée d'attente du
"plouf" (en seconde) et $p$ le
profondeur du puits (en mètre).
On admet que les paramètres $t$ et $p$ sont liés par la relation physique suivante : $t=\sqrt{\frac{p}{4.9}}+\frac{p}{330}$.
-
Première partie : une fois la notion précondition vue
Proposer une fonction temps qui prend en paramètre la profondeur $p$ du puits et
renvoie le temps $t$ d'attente du "plouf".
Penser à importer la fonction sqrt du module math.
-
Vérifier que l'on obtient l'affichage suivant pour l'exécution du script suivant :
>>>temps(30)
2.5652673874360583
-
Rajouter à votre programme deux préconditions sur $p$.
-
Seconde partie : une fois la notion postcondition vue
Rajouter à votre programme une postcondition sur le valeur renvoyée.
-
Rajouter une documentation à la fonction temps.
Cliquer pour afficher la solution
-
from math import sqrt
def temps(p: float) -> float:
t = sqrt(p / 4.9) + p / 330
return t
-
temps(30)
L'appel renvoie 2.5652673874360583
-
from math import sqrt
def temps(p: float) -> float:
assert type(p) == float, "Veuillez saisir un nombre réel comme argument de la fonction temps."
assert p >= 0, "Veuillez saisir un nombre positif comme argument de la fonction temps."
t = sqrt(p / 4.9) + p / 330
return t
-
from math import sqrt
def temps(p: float) -> float:
assert type(p) == float, "Veuillez saisir un nombre réel comme argument de la fonction temps."
assert p >= 0, "Veuillez saisir un nombre positif comme argument de la fonction temps."
t = sqrt(p / 4.9) + p / 330
assert t >= 0, "Le nombre renvoyé devrait être un nombre positif."
return t
-
from math import sqrt
def temps(p: float) -> float:
"""
fonction donnant le temps nécessaire pour entendre le "plouf" d\'une pierre lâchée au-dessus d\'un puits de profondeur p
entrée :
p : nombre réel (profondeur du puits)
sortie :
t : nombre réel (temps d\'attente)
"""
assert type(p) == float, "Veuillez saisir un nombre réel comme argument de la fonction temps."
assert p >= 0, "Veuillez saisir un nombre positif comme argument de la fonction temps."
t = sqrt(p / 4.9) + p / 330
assert t >= 0, "Le nombre renvoyé devrait être un nombre positif."
return t
L'énergie cinétique d'un objet de masse $m$ (en kg) qui se déplace à la vitesse $v$ (en $m.s^{-1}$) est donnée par la formule : $E_c=\frac{1}{2}\times m \times v^2$.
-
Écrire une fonction nommée get_energie_cinetique ayant comme paramètres la masse
m et la vitesse v qui renvoie l'énergie cinétique.
-
Est-ce une fonction ou une procédure ? Pourquoi ?
-
Quelle est l'énergie (en Joule) d'un objet de 3 kg se déplaçant à 1.56 $m.s^{-1}$ ?
Cliquer pour afficher la solution
-
def get_energie_cinetique(m: float, v:float) -> float:
"""
m est la masse d'un objet en kilogramme,
v représente la vitesse de l'objet en m/s.
Cette fonction renvoie l'énergie cinétique de l'objet en Joule.
"""
Ev = 1/2* m * v**2
return Ev
-
C'est une fonction car il y a un renvoi, ici d'un flottant.
-
get_energie_cinetique(3, 1.56)
renvoie 3.6504000000000003.
L'énergie cinétique de l'objet est d'environ 3.65 Joules.
-
Écrire une fonction saisir_num_tel qui ne prend pas de paramètre mais renvoie le numéro de téléphone saisi par l'utilisateur comme chaîne de caractères.
-
Est-ce une fonction ou une procédure ? Pourquoi ?
-
Écrire une fonction nommée prevenir_message ayant comme paramètre un numéro de téléphone qui affiche "Vous allez recevoir un message de confirmation au .........." où apparaît le numéro de téléphone
saisi.
Exemple : prevenir_message("0665432100") affiche "Vous allez recevoir un message de confirmation au 0665432100.".
-
Est-ce une fonction ou une procédure ? Pourquoi ?
-
Intégrer ces deux fonctions pour faire apparaître un programme qui :
Cliquer pour afficher la solution
-
def saisir_num_tel() -> str:
"""
fonction qui renvoie sous forme de chaîne de caractères le numéro de téléphone demandé à l'utilisateur
"""
tel = input("Quel est votre numéro de téléphone ?") # ne pas transtyper sous forme d'entier pour ne pas perdre le 0 du début.
return tel
-
Comme la fonction renvoie quelque chose, c'est bien une fonction et non une procédure.
-
def prevenir_message(num: str) -> None:
"""
num est une chaîne de caractères correspondant à un numéro de téléphone.
C'est procédure qui affiche un message en lien avec le numéro de téléphone saisi
"""
print("Vous allez recevoir un message de confirmation au", num)
-
Comme la fonction ne renvoie rien, c'est bien une procédure.
-
numero = saisir_num_tel()
prevenir_message(numero)
-
Écrire une fonction nommée get_moyenne5 qui renvoie la moyenne de cinq nombres quelconques passés
en arguments.
-
Proposer une précondition portant sur chacun des paramètres d'entrée pour assurer que la possibilité de calculer
la somme.
Cliquer pour afficher la solution
-
def get_moyenne5(a: float, b: float, c: float, d: float, e: float) -> float:
"""
a, b, c, d et e sont 5 nombres décimaux ou entiers.
fonction qui renvoie la moyenne des cinq nombres saisis comme argument.
"""
moy = (a + b + c + d + e)/5
return moy
-
def get_moyenne5(a: float, b: float, c: float, d: float, e: float) -> float:
"""
a, b, c, d et e sont 5 nombres décimaux ou entiers.
fonction qui renvoie la moyenne des cinq nombres saisis comme argument.
"""
# 5 préconditions rajoutées
assert type(a) == int or type(a) == float, "tout argument saisi doit être un nombre"
assert type(b) == int or type(b) == float, "tout argument saisi doit être un nombre"
assert type(c) == int or type(c) == float, "tout argument saisi doit être un nombre"
assert type(d) == int or type(d) == float, "tout argument saisi doit être un nombre"
assert type(e) == int or type(e) == float, "tout argument saisi doit être un nombre"
moy = (a + b + c + d + e)/5
return moy
Voici une écriture possible en langage Python d'une fonction qui prend en paramètre un entier naturel n
et qui renvoyant la somme de tous les nombres entiers compris entre 0 et n :
def tous_additionner(n):
s = 0
for i in range(1, n+1):
s = s + i
return s
-
Documenter la fonction précédente en ajoutant un docstring et préciser le typage des paramètres.
-
Proposer des préconditions écrites sur la variable n en utilisant le mot-clef assert qui assurent le bon usage de cette fonction exo6.
-
Proposer un postcondition écrite sur la variable renvoyée.
Cliquer pour afficher la solution
-
def tous_additionner(n: int) -> int:
"""
n est un nombre entier
fonction qui renvoie la somme de tous les nombres entiers compris entre 0 et le nombre n saisi
"""
s = 0
for i in range(1, n+1):
s = s + i
return s
-
def tous_additionner(n: int) -> int:
"""
n est un nombre entier
fonction qui renvoie la somme de tous les nombres entiers compris entre 0 et le nombre n saisi
"""
# Ajout d'une précondition portant sur le type et sur la plage de valeurs possibles
assert type(n) == int and n >= 0, "l'argument saisi doit être un nombre entier positif"
s = 0
for i in range(1, n+1):
s = s + i
return s
-
def tous_additionner(n: int) -> int:
"""
n est un nombre entier
fonction qui renvoie la somme de tous les nombres entiers compris entre 0 et le nombre n saisi
"""
assert type(n) == int and n >= 0, "l'argument saisi doit être un nombre entier positif"
s = 0
for i in range(1, n+1):
s = s + i
# Ajout d'une postcondition portant sur le type et sur la plage de valeurs possibles pour la valeur renvoyée
assert type(s) == int and s >= 0, "la valeur renvoyée devrait être un nombre entier positif"
return s
Voici une écriture possible en langage Python de l'algorithme d'une fonction qui prend en
paramètres deux chaînes de caractères phrase et lettre et
qui renvoie la chaîne de caractères phrase où tous les caractères
lettre ont été ôtés :
def supprimer(phrase, lettre):
fin = ""
for elt in phrase:
if elt != lettre:
fin = fin + elt
return fin
-
Documenter la fonction précédente en ajoutant un docstring et préciser le typage de chaque paramètre.
-
Proposer des préconditions écrites sur les variables phrase et lettre en utilisant le mot-clef assert qui assurent le bon usage de cette fonction exo15.
L'expression len(chaine) prend comme valeur le nombre de caractères de la chaîne de caractères
nommée chaine.
-
Proposer un postcondition écrite sur la variable renvoyée.
Cliquer pour afficher la solution
-
def supprimer(phrase: str, lettre: str) -> str:
"""
phrase est une chaîne de caractères
lettre est un unique caractère
fonction qui renvoie la phrase initiale où tous les caractères lettre ont été ôtés.
"""
fin = ""
for elt in phrase:
if elt != lettre:
fin = fin + elt
return fin
-
def supprimer(phrase: str, lettre: str) -> str:
"""
phrase est une chaîne de caractères
lettre est un unique caractère
fonction qui renvoie la phrase initiale où tous les caractères lettre ont été ôtés.
"""
# ajout de deux préconditions portant sur le type et la longueur des arguments saisis
assert type(phrase) == str, "le premier argument doit être une chaîne de caractères"
assert type(lettre) == str and len(lettre), "le second argument doit être une chaîne de caractères réduite à un seul caractère"
fin = ""
for elt in phrase:
if elt != lettre:
fin = fin + elt
return fin
-
def supprimer(phrase: str, lettre: str) -> str:
"""
phrase est une chaîne de caractères
lettre est un unique caractère
fonction qui renvoie la phrase initiale où tous les caractères lettre ont été ôtés.
"""
assert type(phrase) == str, "le premier argument doit être une chaîne de caractères"
assert type(lettre) == str and len(lettre), "le second argument doit être une chaîne de caractères réduite à un seul caractère"
fin = ""
for elt in phrase:
if elt != lettre:
fin = fin + elt
# ajout d'une postcondition portant sur le type de la valeur renvoyée
assert type(fin) == str, "la valeur renvoyée doit être une chaîne de caractères"
return fin
QCM
Questions issues de la Banque Nationale de Sujets
Propriétaire des ressources ci-dessous : ministère de l'Éducation nationale et de la jeunesse, licence CC BY SA NC
Voici une sélection de questions issues de la banque nationale de sujets, répondez à ces questions (attention, cette sélection n'est pas exhaustive).
On définit deux fonctions :
def f(x):
y = 2*x + 1
return y
def calcul(x):
y = x - 1
return f(y)
Quelle est la valeur renvoyée par l'appel calcul(5) ?
Réponses :
A- 4
B- 9
C- 11
D- 19
On exécute le code suivant
a = 2
b = 3
c = a ** b
d = c % b
Quelle est la valeur de d à la fin de l'exécution ?
Réponses :
A- 1
B- 2
C- 3
D- 4
On définit L = [2, 3, 5, 7, -4].
En demandant la valeur de L[5], qu'obtient-on ?
Réponses :
A- -4
B- 2
C- 3
D- une erreur
On définit L = [4, 25, 10, 9, 7, 13].
Quelle est la valeur de L[2] ?
Réponses :
A- 4
B- 25
C- 10
D- 9
En Python, quelle est la méthode pour charger la fonction sqrt du module math ?
Réponses :
A- using math.sqrt
B- #include math.sqrt
C- from math include sqrt
D- from math import sqrt
On exécute le script suivant :
def calcul(a, b):
a = a + 2
b = b + 5
c = a + b
return c
a, b = 3, 5
calcul(a, b)
À la fin de cette exécution :
Réponses :
A- a vaut 3, b vaut 5 et c vaut 15
B- a vaut 3, b vaut 5 et c n'est pas défini
C- a vaut 5, b vaut 10 et c vaut 15
D- a vaut 5, b vaut 10 et c n'est pas défini
On exécute le script suivant :
def essai():
a = 2
b = 3
c = 4
return a
return b
return c
t = essai()
Quelle est la valeur de t après l'exécution de ce code ?
Réponses :
A- 2
B- 3
C- 4
D- (2, 3, 4)
La fonction suivante calcule la racine carrée du double d’un nombre flottant :
from math import sqrt
def racine_du_double(x):
return sqrt(2*x)
Quelle est la précondition sur l'argument de cette fonction ?
Réponses :
A- x
< 0
B- x >= 0
C- 2 * x > 0
D- sqrt(x) >= 0
On définit la fonction :
def f(a, b):
assert b!=0,'le deuxième argument est nul'
result = a/b
return result
Qu'obtient-on en exécutant la commande r = f(4, 0) ?
Réponses :
A- Une erreur "ZeroDivisionError: division by zero" et l'arrêt de l'exécution
B- Une erreur "NameError: name 'b' is not defined" et l'arrêt de l'exécution
C- Une erreur "AssertionError: le deuxième argument est nul" et la variable r prend la valeur 0
D- Une erreur "AssertionError: le deuxième argument est nul" et l'arrêt de l'exécution
Autres QCM
Les QCM suivants sont issus de https://genumsi.inria.fr.
(Auteur Nicolas Revéret)
On souhaite écrire un programme calculant le triple d'un nombre décimal et affichant le résultat. On a saisi le code suivant :
nombre = input("Saisir un nombre")
triple = nombre * 3
print(triple)
Un utilisateur saisit le nombre 5 lorsque l'ordinateur lui demande. Quel va être le résultat affiché ?
Réponses :
A- nombrenombrenombre
B- 555
C- 15
D- 15.0
(Auteur Nicolas Revéret)
On a saisi le code suivant :
nombre = int (input("Saisir un nombre") )
double = nombre * 2
print(double)
Quel message affiche l’ordinateur lorsque l'utilisateur saisit 8.5 ?
Réponses :
A- 16
B- 16.0
C- 17
D- L'ordinateur affiche une erreur
(Auteur Nicolas Revéret)
On a saisi le code suivant :
a = 8
b = 5
a = a + b
b = a - b
a = a - b
Quelles sont les valeurs de a et b à la fin du programme ?
Réponses :
A- a = 8 et b = 5
B- a = 8 et b = 13
C- a = 5 et b = 8
D- a = 13 et b = 5
(Auteur Christophe BEASSE)
Que contiennent les variables a et b si on execute ce script ?
def func(a):
a += 2.0 # revient à : a = a + 2.0
return a
a = 5.0
b = func(a)
Quelles sont les valeurs de a et b à la fin du programme ?
Réponses :
A- 5.0 et 5.0
B- 5.0 et 7.0
C- 7.0 et 5.0
D- 7.0 et 7.0
(Auteur Pierre Marquestaut)
On considère le code suivant :
def fonction(nombre):
global a
a = 4
return a+nombre
a = 5
b = fonction(3)
print(a)
Qu'est-ce qui s'affiche après le code précédent ?
Réponses :
A- 3
B- 4
C- 5
D- 7
(Auteur Philippe PICART)
La fonction ci-dessous calcule la température en °F (Fahrenheit) à partir d’une température en °C (Celsius). On a saisi le code suivant :
On a saisi le code suivant :
def convertir(temp_c):
temp_f = temp_c *1.8+32
return temp_f
a = .....................................
print("la température en °F est de ", a)
Quelle instruction doit-on choisir pour appeler la fonction avec une température de 20 °C ?
Réponses :
A- a = convertir(20°C)
B- a = convertir("20")
C- a = int(input("saisir la temp en °C"))
D- a = convertir(20)
(Auteur Eric Buonocore)
type(abs(-42)) nous renseigne sur le type de la valeur retour de abs(-42) :
>>> type(abs(-42))
Quel est le type de la valeur retour de print("coucou") ?
>>> type(print("coucou"))
coucou
Réponses :
A- <class 'int'>
B- <class 'str'>
C- <class 'NoneType'>
D- <class 'coucou'>
(Auteur Jean-Louis Thirot)
On a exécuté le code suivant :
cote = input("quelle est la longueur du coté du carré ?")
aire = cote**2
print(aire)
On obtient le message d'erreur suivant :
Traceback (most recent call last):
File "", line 2, in
TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'int'
Que signifie ce message d'erreur ?
Réponses :
A- On a utilisé une variable qui n'est pas définie
B- On a mal indenté le code
C- On a fait une erreur de syntaxe
D- On effectue une opération impossible entre deux valeurs de types différents
Savoir faire et Savoir
- Savoir la définition d'une variable
- Savoir la définition d'un type
- Savoir la définition d'une affectation
- Savoir qu'une variable peut contenir des données de différents types
- Savoir définir la notion de fonction
- Savoir ce qu'est une chaîne de caractères
- Savoir la différence entre paramètre et argument
- Savoir la différence entre variable locale et globale
- Savoir la portée d'une variable à l'intérieur d'une fonction
- Savoir ce qu'est une précondition et une post condition
- Savoir ce qu'est une trace d'exécution
- Savoir nommer une variable en Python
- Savoir écrire une affection en Python
- Savoir afficher à l'aide de la fonction
print
- Savoir faire saisir depuis le clavier à l'aide de la fonction
input
- Saisir changer de type avec la fonction
int
- Savoir écrire une fonction en Python
- Savoir appeler une fonction
- Savoir typer les paramètres d'une fonction
- Savoir écrire la documentation d'une fonction
- Savoir déclarer une variable globale en Python
- Savoir écrire une précondition à l'aide du mot-clé
assert
- Savoir écrire une postcondition à l'aide du mot-clé
assert
Remédiation
En cas de difficultés persistantes sur certaines notions de ce chapitre,
vous pouvez essayer de retravailler ces notions sur le site
futurecoder de la forge.
Ce site propose un cours complet pour débutant, avec des exercices interactifs,
un système d’aide très bien fait et des débugueurs variés.
Parmi les parties proposées au niveau de la "Table des matières",
les pages liées aux "Variables" et aux "Fonctions" sont celles le plus en lien avec le chapitre.
Pour la partie "Fonctions de tests", la fonction assert_equal spécifique au site futurecoder est une
manière de tester des assertions sans le mot-clé assert.
La partie "return termine l'appel de la fonction" est difficile car nécessite de maîtriser
les boucles for. De plus, ne vous attardez pas sur l'utilisation du mot-clé break.
Vous avez à lire les explications apparaissant à gauche, à saisir les
scripts demandés dans la console à droite et de vous laisser guider tout au long des parties.
Espace vidéos
Utilisation de la console EDUPYTHON :
Présentation de JUPYTER :
Les fonctions (en mode console EDUPYTHON) :